package Vista;

import Controlador.Controlador;
import Modelo.CalculosDatos;
import Modelo.ElementoGmaps;
import Modelo.GoogleMaps;
import GUI.InicioAplicacion;
import Modelo.ElementoPOI;
import Utils.CoordUTM;
import Utils.Ficheros.FicheroDatos;
import Utils.Util;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Insets;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.Vector;
import javax.swing.JPanel;
import javax.swing.border.Border;

/**
 *
 * @author Javier Doria
 */
public class Geomantes implements Border {

    private int[] datosEntrada; //Desplazamiento en pixeles (mirar bien)
    private double velocidad; //Velocidad actual
    private double distancia; //Distancia recorrida
    private Image nomap; //Imagen sin mapa
    private double longitudAntigua, longitudActual, latitudAntigua, latitudActual;
    private double latCentro, longCentro; //Latitudes y longitudes del punto actual, antiguo y central original
    private double escala; //Relación metros/pixel actual
    private static Controlador controlador;
    private int nivelZoom; //Por defecto 17
    private String mapType; //Tipo de mapa: hybrid, terrain, satellite, roadmap
    private String tipoVel; //Km/h o mph
    private FicheroDatos coordenadas;
    private FicheroDatos coordenadasAntiguas;
    private int despX; //Desplazamiento X en pixeles desde la posición inicial
    private int despY; //Desplazamiento Y en pixeles desde la posición inicial
    private int ancho; //Ancho de la pantalla
    private int alto;  //Alto de la pantalla
    private GoogleMaps googlemaps; //Variable de la clase GoogleMaps
    private ElementoGmaps[][] matrizGMaps; //Matriz de mapas GoogleMaps
    private ElementoGmaps[][] matrizMemoria; //Matriz de mapas en memoria
    private JPanel displayMapa; //Display actual
    private boolean modoDragged; //Indica que se está explorando el mapa (dragg)
    private Vector listaPOI; //Lista con los POI
    private Color colorRuta1, colorRuta2, colorRuta3;
    //
    //
    //
    //
    /*
    private Vector ruta;
    private int RUTA_MAX_SIZE = 50;
    private int[] posicionMapa;
    
    private boolean mostrarRuta;
    private String rutaMapas;
    private String nombre;
    private String nombremapa;

    private Image titulo;
    private String message;
    private Calendar c = Calendar.getInstance();
    private String fecha;
    private boolean modoGuiado;
    private int numPuntosPasados;
    private int numActualizaciones;
    double resta;
    private double angleGuiado;

    private int flag = 0;
    private double angle;
    private Image brujula;
    private final float degree = (float) (2 * Math.PI / 360.0);
    private final int X = 0;
    private final int Y = 1;
    private int centerX;
    private int centerY;
    //Posicion de objetos en pantalla
    private int altInfo;
    private int altEspacio;
    private int ancho;
    private int alto;
    private int tamVel;
    private int tamDist;
    private int tamBruj;
    private int tamBordeBruj;
    private int tamInfo;
    private int tamBordeInfo;
    private int altInferior;
    //Opciones del interfaz
    private boolean modoExperto;
    //Variable booleana para determinar si es necesario limpiar la pantalla
    private boolean limpiaDisplay;
    private Image flecha;
    private Image flagFinish;
    private Image checkpoint;
    private Image rotuloCheck;
    private Image finDeRuta;
    private Image rotuloVelocidad;
    private Image start;
    private boolean modoGoogle;
    private Image norte;
    private Image sur;
    private Image este;
    private Image oeste;
    private Image noreste;
    private Image noroeste;
    private Image sureste;
    private Image suroeste;
    private boolean guardandoPOI;
    private boolean borrarPOI;
    private int contadorPOI;
     */

    public Geomantes() throws Exception {
        super();
        inicializarValores();
    }
    /*
    try {
    norte = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/norte.png"));
    sur = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/sur.png"));
    este = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/este.png"));
    oeste = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/oeste.png"));
    noroeste = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/noroeste.png"));
    noreste = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/noreste.png"));
    suroeste = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/suroeste.png"));
    sureste = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/sureste.png"));
    flagFinish = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/Imagenes/rutaFin.png"));
    checkpoint = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/checkpoint.png"));
    rotuloCheck = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/rotulocheck.png"));
    finDeRuta = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/finderuta.png"));
    rotuloVelocidad = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/rotulovelocidad.png"));
    start = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/rutaInicio.png"));
    } catch (Exception e) {
    e.printStackTrace();
    }*/
    /*
    try {
    InputStream in = null;
    in = getClass().getResourceAsStream("/ContinueRecto22.wav");
    todorecto = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/MediaVuelta22.wav");
    mediavuelta = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/GireDerecha22.wav");
    derecha = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/GireIzquierda22.wav");
    izquierda = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/GireLigeramenteIzquierda22.wav");
    ligizquierda = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/GireLigeramenteDerecha22.wav");
    ligderecha = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/cienMetros22.wav");
    cienmetros = Manager.createPlayer(in, "audio/x-wav");
    in = getClass().getResourceAsStream("/cincuentaMetros22.wav");
    cincuentametros = Manager.createPlayer(in, "audio/x-wav");
    } catch (IOException ex) {
    ex.printStackTrace();
    } catch (MediaException ex) {
    ex.printStackTrace();
    }
     */

    public void setColor1(Color a) {
        colorRuta1 = a;
    }

    public void setColor2(Color a) {
        colorRuta2 = a;
    }

    public void setColor3(Color a) {
        colorRuta3 = a;
    }

    public void setCoordenadas(FicheroDatos c) {
        coordenadas = c;
    }

    public FicheroDatos getCoordenadas() {
        return coordenadas;
    }

    public void setInfoFichero(FicheroDatos infolinea, int[] datosEntrada, double velocidad, double distancia) {
        if (distancia >= 0) {
            this.distancia = this.distancia + distancia;
        }
        this.datosEntrada = datosEntrada;
        this.velocidad = velocidad;
        if (tipoVel.equals("km/h")) {
            this.velocidad = velocidad * 3.6;
        } else {
            if (tipoVel.equals("mph")) {
                this.velocidad = velocidad * 2.23693629;
            }
        }
        /*
        //Entramos si no es la primera vez, y por lo tanto coordenadas tiene
        //un valor distinto a -1 en sus atributos.
        if ((coordenadas.getLatitud() != -1) && (coordenadas.getLongitud() != -1)) {
        angle = (Utils.mMath.atan((infolinea.getLatitud() - coordenadas.getLatitud()) / (infolinea.getLongitud() - coordenadas.getLongitud())) * 180);
        angle = angle / Math.PI;
        //Dependiendo de en que cuadrante estemos, transformamos el angulo
        //para que la brujula lo muestre correctamente
        if (infolinea.getLongitud() >= coordenadas.getLongitud()) {
        if (infolinea.getLatitud() < coordenadas.getLatitud()) {   //Cuarto cuadrante
        angle = 360 + angle;
        }
        } else {
        angle = 180 + angle;
        }
        //Encontramos el mapa central y archivamos sus coordenadas
        //posicionMapa = FicheroMap.calculoMapaCentral(nombremapa, coordenadas);
        }
        coordenadas.clone(infolinea);

        if (modoGuiado) {
        //angleGuiado = controlador.getLocation().getCourse();
        //velocidad = controlador.getLocation().getSpeed();
        if (coordenadasAntiguas.getLatitud() != -1) {
        if (numActualizaciones == 0) {
        //angleGuiado = calcularBearing(coordenadasAntiguas.getLatitud(), coordenadasAntiguas.getLongitud(),
        //        infolinea.getLatitud(), infolinea.getLongitud());
        coordenadasAntiguas.clone(infolinea);
        }
        } else {
        coordenadasAntiguas.clone(infolinea);
        }
        }*/
    }

    private boolean estaCompleta(ElementoGmaps[][] matriz) {
        int i = 0;
        boolean completa = true;
        while (completa && i < matriz.length) {
            int j = 0;
            while (completa && j < matriz.length) {
                if (matriz[i][j].getImagen() != null) {
                    j++;
                } else {
                    completa = false;
                }
            }
            i++;
        }
        return completa;
    }

    private void inicializarMemoria() {
       if (CalculosDatos.getNumFilas() == 0 && CalculosDatos.getNumColumnas() == 0) {
            matrizMemoria = new ElementoGmaps[1][1];
            matrizMemoria[0][0] = new ElementoGmaps();
            try {
                datosEntrada = CalculosDatos.calcular(coordenadas);
                String imagen = CalculosDatos.getRutaImagen() + CalculosDatos.getFicheroImagen() + CalculosDatos.getExtensionImagen();
                Image mapa = Toolkit.getDefaultToolkit().getImage(imagen);
                matrizMemoria[0][0].setImagen(mapa);
                CalculosDatos.setNumColumnas(1);
                CalculosDatos.setNumFilas(1);
            } catch (Exception ex) {
                //j = j - 1;
                ex.printStackTrace();
            }
        } else {
            datosEntrada = CalculosDatos.calcular(coordenadas);
            matrizMemoria = new ElementoGmaps[CalculosDatos.getNumFilas()][CalculosDatos.getNumColumnas()];
            for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                    matrizMemoria[i][j] = new ElementoGmaps();
                }
            }

            for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                    try {
                        String imagen = CalculosDatos.getRutaImagen() + CalculosDatos.getFicheroImagen() + i + "_" + j + CalculosDatos.getExtensionImagen();
                        Image mapa = Toolkit.getDefaultToolkit().getImage(imagen);
                        matrizMemoria[i][j].setImagen(mapa);

                    } catch (Exception ex) {
                        //j = j - 1;
                        ex.printStackTrace();
                    }
                }
            }
        }
    }

    private void paintMapasMemoria(Graphics g) {
        //paintNotFound(g);
        try {
            //Si estÃ¡ vacÃ­a la matriz de mapas, la inicializamos
            if (matrizMemoria == null) {
                inicializarMemoria();
            } else {
                if (estaCompleta(matrizMemoria)) {
                    for (int i = 0; i < CalculosDatos.getNumFilas(); i++) {
                        for (int j = 0; j < CalculosDatos.getNumColumnas(); j++) {
                            Image img = matrizMemoria[i][j].getImagen();
                            g.drawImage(
                                    img,
                                    (j * img.getWidth(null)) - datosEntrada[2] + displayMapa.getWidth() / 2,
                                    (i * img.getHeight(null)) - datosEntrada[3] + displayMapa.getHeight() / 2,
                                    displayMapa);
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void inicializarGmaps() {
        matrizGMaps = new ElementoGmaps[3][3];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                matrizGMaps[i][j] = new ElementoGmaps();
            }
        }
        try {
            matrizGMaps[1][1].setImagen(googlemaps.retrieveStaticImage(displayMapa.getWidth(), displayMapa.getHeight(), coordenadas.getLatitud(), coordenadas.getLongitud(), nivelZoom, "png", mapType));
            matrizGMaps[1][1].setLongitud(coordenadas.getLongitud());
            matrizGMaps[1][1].setLatitud(coordenadas.getLatitud());
        } catch (Exception ex) {
            System.out.println("Google reintenta coger mapa");
            ex.printStackTrace();
        }

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i != 1 || j != 1) {
                    int difI = i - 1;
                    int difJ = j - 1;
                    try {
                        double[] latlon = Util.adjust(matrizGMaps[1][1].getLatitud(),
                                matrizGMaps[1][1].getLongitud(),
                                displayMapa.getWidth() * difJ, displayMapa.getHeight() * difI, nivelZoom);
                        matrizGMaps[i][j].setImagen(googlemaps.retrieveStaticImage(displayMapa.getWidth(), displayMapa.getHeight(),
                                latlon[1], latlon[0], nivelZoom, "png", mapType));
                        matrizGMaps[i][j].setLongitud(latlon[0]);
                        matrizGMaps[i][j].setLatitud(latlon[1]);
                    } catch (Exception ex) {
                        //j = j - 1;
                        ex.printStackTrace();
                    }
                }
            }
        }
        despX = 0;
        despY = 0;
    }

    private void paintMapasGoogle(Graphics g) {
        //Pintamos un fondo estandar por si algun mapa no carga correctamente
        //paintNotFound(g);
        try {
            //Si estÃ¡ vacÃ­a la matriz de mapas, la inicializamos
            if (matrizGMaps == null) {
                latCentro = coordenadas.getLatitud();
                longCentro = coordenadas.getLongitud();
                latitudAntigua = coordenadas.getLongitud();
                longitudAntigua = coordenadas.getLongitud();
                latitudActual = coordenadas.getLatitud();
                longitudActual = coordenadas.getLongitud();
                inicializarGmaps();
            } else {
                latitudAntigua = latitudActual;
                longitudAntigua = longitudActual;
                latitudActual = coordenadas.getLatitud();
                longitudActual = coordenadas.getLongitud();
                CoordUTM CoordUTMAntigua = Util.LLtoUTM(23, latitudAntigua, longitudAntigua); // origen
                CoordUTM CoordUTMActual = Util.LLtoUTM(23, latitudActual, longitudActual); // destino
                int incX = (int) (Math.floor(-(CoordUTMActual.getUTMEasting() - CoordUTMAntigua.getUTMEasting()) * (1 / escala) + 0.5d));
                int incY = (int) (Math.floor((CoordUTMActual.getUTMNorthing() - CoordUTMAntigua.getUTMNorthing()) * (1 / escala) + 0.5d));
                despY = despY + incY;
                despX = despX + incX;

                if (estaCompleta(matrizGMaps)) {
                    for (int i = 0; i < 3; i++) {
                        for (int j = 0; j < 3; j++) {
                            Image img = matrizGMaps[i][j].getImagen();
                            g.drawImage(
                                    img,
                                    (j - 1) * displayMapa.getWidth() + despX,
                                    (i - 1) * displayMapa.getHeight() + despY,
                                    displayMapa);
                        }
                    }
                }
                // Si nos hemos salido de los margenes del mapa, recalculamos la matriz
                if ((Math.abs(despX) >= displayMapa.getWidth() / 2 || Math.abs(despY) >= displayMapa.getHeight() / 2) && modoDragged == false) {
                    desplazaMapasGmaps();
                }
            }
        } catch (Exception e) {
            System.out.println("Exception Google Maps");
        }
    }

    public void guardarMapas() {
        if (matrizGMaps != null) {
            controlador.guardarMapaGoogle(
                    3,
                    matrizGMaps,
                    googlemaps,
                    displayMapa.getWidth(),
                    displayMapa.getHeight());
        }
    }

    private void desplazaMapasGmaps() {
        int mitadAltura = matrizGMaps[0][0].getImagen().getHeight(null) / 2;
        int mitadAnchura = matrizGMaps[0][0].getImagen().getWidth(null) / 2;

        //Laterales
        //Se sale por la derecha
        if (despX < -mitadAnchura && despY > -mitadAltura && despY < mitadAltura) {
            despX = mitadAnchura - (Math.abs(despX) - mitadAnchura);
            double longitudIni = matrizGMaps[1][2].getLongitud();
            double latitudIni = matrizGMaps[1][2].getLatitud();
            for (int m = 0; m < 3; m++) {
                for (int n = 0; n < 2; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m][n + 1].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m][n + 1].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m][n + 1].getLongitud());
                }
            }

            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2), (mitadAltura * 2) * difJ, nivelZoom);
                    matrizGMaps[j][2].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[j][2].setLatitud(latlon[1]);
                    matrizGMaps[j][2].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }

        //Se sale por la izquierda
        if (despX > mitadAnchura && despY > -mitadAltura && despY < mitadAltura) {
            despX = (despX - mitadAnchura) - mitadAnchura;
            double longitudIni = matrizGMaps[1][0].getLongitud();
            double latitudIni = matrizGMaps[1][0].getLatitud();
            for (int m = 0; m < 3; m++) {
                for (int n = 2; n > 0; n--) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m][n - 1].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m][n - 1].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m][n - 1].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            -(mitadAnchura * 2), (mitadAltura * 2) * difJ, nivelZoom);
                    matrizGMaps[j][0].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[j][0].setLatitud(latlon[1]);
                    matrizGMaps[j][0].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        //Se sale por arriba
        if (despX > -mitadAnchura && despX < mitadAnchura && despY < -mitadAltura) {
            despY = mitadAltura - (Math.abs(despY) - mitadAltura);

            double longitudIni = matrizGMaps[2][1].getLongitud();
            double latitudIni = matrizGMaps[2][1].getLatitud();
            for (int m = 0; m < 2; m++) {
                for (int n = 0; n < 3; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m + 1][n].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m + 1][n].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m + 1][n].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2) * difJ, (mitadAltura * 2), nivelZoom);
                    matrizGMaps[2][j].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[2][j].setLatitud(latlon[1]);
                    matrizGMaps[2][j].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
        //Se sale por abajo
        if (despX > -mitadAnchura && despX < mitadAnchura && despY > mitadAltura) {
            despY = (despY - mitadAltura) - mitadAltura;
            double longitudIni = matrizGMaps[0][1].getLongitud();
            double latitudIni = matrizGMaps[0][1].getLatitud();
            for (int m = 2; m > 0; m--) {
                for (int n = 0; n < 3; n++) {
                    matrizGMaps[m][n].setImagen(matrizGMaps[m - 1][n].getImagen());
                    matrizGMaps[m][n].setLatitud(matrizGMaps[m - 1][n].getLatitud());
                    matrizGMaps[m][n].setLongitud(matrizGMaps[m - 1][n].getLongitud());
                }
            }
            for (int j = 0; j < 3; j++) {
                int difJ = j - 1;
                try {
                    double[] latlon = Util.adjust(latitudIni, longitudIni,
                            (mitadAnchura * 2) * difJ, -(mitadAltura * 2), nivelZoom);
                    matrizGMaps[0][j].setImagen(googlemaps.retrieveStaticImage(mitadAnchura * 2, mitadAltura * 2,
                            latlon[1],
                            latlon[0], nivelZoom, "png", mapType));
                    matrizGMaps[0][j].setLatitud(latlon[1]);
                    matrizGMaps[0][j].setLongitud(latlon[0]);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    /**
     * Metodo que dibuja por pantalla un fondo que se mostrarÃ¡ por debajo del mapa
     * @param g objeto de tipo Graphics
     */
    private void paintNotFound(Graphics g) {
        //Establecemos el color de fondo y reiniciamos la pantalla
        //g.setColor(Color.WHITE);
        //g.fillRect(0, 0, displayMapa.getWidth(), displayMapa.getHeight());
        /*if (matrizGMaps == null && matrizMemoria == null) {
        g.setColor(new Color(0x000000));
        g.fillRect(0, 0, ancho, displayMapa.getHeight());
        for (int i = 0; i <= ancho / nomap.getWidth(null); i++) {
        for (int j = 0; j <= displayMapa.getHeight() / nomap.getHeight(null); j++) {
        g.drawImage(nomap, i * nomap.getWidth(null), j * nomap.getHeight(null), null);
        }
        }
        }*/
    }

    /**
     * MÃ©todo que dibuja una ruta por pantalla
     * @param g objeto de la clase Graphics
     */
    private void paintRuta(Graphics g2) {
        if (controlador.getModoGrabacion() && controlador.getMostrarRuta()) {
            Graphics2D g = (Graphics2D) g2;
            g.setColor(new Color(0x00ff00));
            if (controlador.getVectorRuta().size() > 0) {
                g.setColor(new Color(255, 0, 0));
                g.drawOval(
                        ancho / 2 - datosEntrada[2] + ((int[]) controlador.getVectorRuta().elementAt(0))[2] - 6,
                        alto / 2 - datosEntrada[3] + ((int[]) controlador.getVectorRuta().elementAt(0))[3] - 6, 10, 10);
                g.fillOval(ancho / 2 - datosEntrada[2] + ((int[]) controlador.getVectorRuta().elementAt(0))[2] - 6,
                        alto / 2 - datosEntrada[3] + ((int[]) controlador.getVectorRuta().elementAt(0))[3] - 6, 10, 10);
            }

            for (int i = 0; i < controlador.getVectorRuta().size() - 1; i++) {
                int xA = ((int[]) controlador.getVectorRuta().elementAt(i))[2];
                int yA = ((int[]) controlador.getVectorRuta().elementAt(i))[3];

                int xB = ((int[]) controlador.getVectorRuta().elementAt(i + 1))[2];
                int yB = ((int[]) controlador.getVectorRuta().elementAt(i + 1))[3];

                g.setStroke(new BasicStroke(4.0f));
                g.setColor(colorRuta2);

                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA,
                        (alto / 2 - datosEntrada[3]) + yA,
                        (ancho / 2 - datosEntrada[2]) + xB,
                        (alto / 2 - datosEntrada[3]) + yB);

                g.setColor(colorRuta1);
                g.setStroke(new BasicStroke(2.0f));
                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA - 2,
                        (alto / 2 - datosEntrada[3]) + yA - 2,
                        (ancho / 2 - datosEntrada[2]) + xB - 2,
                        (alto / 2 - datosEntrada[3]) + yB - 2);

                g.setColor(colorRuta3);
                g.drawLine(
                        (ancho / 2 - datosEntrada[2]) + xA + 2,
                        (alto / 2 - datosEntrada[3]) + yA + 2,
                        (ancho / 2 - datosEntrada[2]) + xB + 2,
                        (alto / 2 - datosEntrada[3]) + yB + 2);
            }
            g.setStroke(new BasicStroke(1.0f));
        }
    }

    private void paintPuntosInteres(Graphics g) {
        if (controlador.getMostrarPOI() && controlador.getListadoPOI() != null) {
            Vector poi = controlador.getListadoPOI().getListaPOI();
            for (int i = 0; i < poi.size(); i++) {
                int xA = (int) ((ElementoPOI) poi.elementAt(i)).getLatPixel();
                int yA = (int) ((ElementoPOI) poi.elementAt(i)).getLongPixel();
                Object aux = poi.elementAt(i);
                Image simbolo = dameImagenPOI((ElementoPOI) aux);
                if (((ElementoPOI) aux).getTipo().compareTo("Otro") == 0) {
                    g.drawImage(
                            simbolo,
                            (ancho / 2 - datosEntrada[2]) + xA - 25,
                            (alto / 2 - datosEntrada[3]) + yA - 45,
                            displayMapa);
                } else {
                    g.drawImage(
                            simbolo,
                            (ancho / 2 - datosEntrada[2]) + xA - 17,
                            (alto / 2 - datosEntrada[3]) + yA - 37,
                            displayMapa);
                }
            }
        }
    }

    /**
     * Existen dos fuentes para los mapas: Los que almacenemos en la memoria
     * permanente del movil o los que conseguimos a traves Google Maps.
     * A su vez, podemos recibir informacion a traves de un dispositivo GPS o
     * de un fichero con una ruta guardada.

     ****************         ***************
     * Mapa Interno * /_  ___\* Google Maps *   <------- FUENTE DE LOS MAPAS
     **************** \ | |  /***************
    /|\         | |          /|\
    |          | |           |
    |          |_|____       |
    +++++++++++++++++    |    \ +++++++++++
    + Lectura Fichero + __|     + SeÃ±al GPS +   <------- FUENTE DE DATOS
    +++++++++++++++++           +++++++++++

     * La adquisicion de datos es transparente a la vista, pero no lo es la
     * fuente de los mapas. En funcion de si se trata de una via u otra,
     * cambiaran los metodos de dibujo.
     */
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
        displayMapa = controlador.getDisplayMapa();
        ancho = displayMapa.getWidth();
        alto = displayMapa.getHeight();

        //Si las coordenadas son validas
        if ((coordenadas.getLatitud() != -1) && (coordenadas.getLongitud() != -1) && (coordenadas.getAltitud() != 777)) {
            //Primero pintamos un fondo por defecto para que se vea detras de
            //los mapas por si hubiese algun problema.
            paintNotFound(g);
            if (controlador.getModoMapas()) {
                paintMapasGoogle(g);
            } else {
                paintMapasMemoria(g);
            }

            if (controlador.getVectorRuta() != null) {
                paintRuta(g);
            }
            if (controlador.getMostrarPOI()) {
                paintPuntosInteres(g);
            }
            //}
            /*
            if (modoGuiado) {
            //paintModoGuiado(g);
            }*/

            if (controlador.getVectorRuta() != null) {
                paintRuta(g);
            }

            //paintBarraInformacionSuperior(g);
            //escribirBarraInformacionSuperior(g);
            //if (modoExperto && !borrarPOI) {
            //    paintBarraInferior(g);
            //    if (modoFichero) {
            //        escribirBarraInferior(g);
            //    } else {
            //        escribirBarraInferiorGPS(g);
            //    }
            //}
            //if (!borrarPOI) {
            //Cambiamos el color y dibujamos el punto del centro de la pantalla
            //que determina nuestra posicion actual

            g.setColor(new Color(0, 70, 180));
            g.fillArc(displayMapa.getWidth() / 2 - 5, displayMapa.getHeight() / 2 - 5, 10, 10, 0, 360);
            g.setColor(new Color(255, 255, 255));
            g.drawArc(displayMapa.getWidth() / 2 - 6, displayMapa.getHeight() / 2 - 6, 10, 10, 0, 360);
            //}
        } else {
            //Pintamos la pantalla por defecto
            paintNotFound(g);
        }
        //paintBarraBotones(g);
    }

    public Insets getBorderInsets(Component c) {
        return new Insets(0, 0, 0, 0);
    }

    public boolean isBorderOpaque() {
        return true;
    }

    public void setSumaLatLong(double lat, double longi) {
        coordenadas.setLatitud(coordenadas.getLatitud() + lat);
        coordenadas.setLongitud(coordenadas.getLongitud() + longi);
    }

    /**
     * @return the nivelZoom
     */
    public int getNivelZoom() {
        return nivelZoom;
    }

    /**
     * @param nivelZoom the nivelZoom to set
     */
    public void setNivelZoom(int nivelZoom) {
        this.nivelZoom = nivelZoom;
    }

    public void setEscala(double e) {
        escala = e;
    }

    public double getEscala() {
        return escala;
    }

    public double getLatitud() {
        return latitudActual;
    }

    public double getLongitud() {
        return longitudActual;
    }

    public double getVelocidad() {
        return velocidad;
    }

    public double getDistancia() {
        return distancia;
    }

    public String getMapType() {
        return mapType;
    }

    public void setMapType(String s) {
        mapType = s;
    }

    public void setModoDragged(boolean b) {
        modoDragged = b;
    }

    private void inicializarValores() {
        controlador = InicioAplicacion.getControlador();
        displayMapa = controlador.getDisplayMapa();
        alto = displayMapa.getHeight();
        ancho = displayMapa.getWidth();
        tipoVel = "km/h";
        distancia = 0;
        datosEntrada = new int[4];
        datosEntrada[2] = 0;
        datosEntrada[3] = 0;
        coordenadas = new FicheroDatos();
        coordenadasAntiguas = new FicheroDatos();
        nomap = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/Imagenes/nomap.jpg"));
        despX = 0;
        despY = 0;
        googlemaps = new GoogleMaps(controlador.getCuentaGoogle());
        escala = 0.91743119266055045871559633027523;
        nivelZoom = 17;
        mapType = "roadmap";
        modoDragged = false;
        colorRuta1 = Color.RED;
        colorRuta2 = Color.GREEN;
        colorRuta3 = Color.RED;
        //posicionMapa = new int[2];
        //mostrarRuta = true;
        //modoExperto = false;
        //limpiaDisplay = true;
        //modoGuiado = false;
        //modoMarcarRuta = false;
        //numPuntosPasados = 0;
        //numActualizaciones = 0;
        //titulo = Toolkit.getDefaultToolkit().getImage(getClass().getResource("/Archivos/GeomantesBlanco.jpg"));
        //fecha = c.get(Calendar.DAY_OF_MONTH) + "/" + c.get(Calendar.MONTH) + 1;
    }

    private Image dameImagenPOI(ElementoPOI poi_element) {
        if (poi_element.getTipo().compareTo("Cafeteria") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/coffee.png")));
        } else if (poi_element.getTipo().compareTo("Restaurante") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/restaurant.png")));
        } else if (poi_element.getTipo().compareTo("Gasolinera") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/gazstation.png")));
        } else if (poi_element.getTipo().compareTo("Direccion") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/home.png")));
        } else if (poi_element.getTipo().compareTo("Hostel") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/hostel.png")));
        } else if (poi_element.getTipo().compareTo("Parking") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/parking.png")));
        } else if (poi_element.getTipo().compareTo("Primeros auxilios") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/firstaid.png")));
        } else if (poi_element.getTipo().compareTo("Baños") == 0) {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/ImagenesIconos/toilets.png")));
        } else {
            return (Toolkit.getDefaultToolkit().getImage(
                    getClass().getResource("/Archivos/Imagenes/poiMarca.png")));
        }
    }

    public ElementoGmaps[][] getMapaActual() {
        if (matrizGMaps != null) {
            return matrizGMaps;
        }
        if (matrizMemoria != null) {
            return matrizMemoria;
        }
        return null;
    }
    
//
//
//
//
//
//
//
//
//
//
//
//
    /*

    public void cargar() {
    // Hace un recorrido completo al fichero donde esta almacenada una ruta
    // y guarda cada punto de informacion en un vector
    CalculosDatos.setInfoFichero(nombremapa);
    FicheroDatos infoLinea = new FicheroDatos();
    InputStream inputStreamTxt = null;
    inputStreamTxt = this.getClass().getResourceAsStream("/" + nombre);
    infoLinea.lecturaFichero(inputStreamTxt);
    ruta = new Vector();

    int contadorMax = 0;
    while ((infoLinea.getLatitud() != -1) && (infoLinea.getLongitud() != -1)) {
    int[] punto = CalculosDatos.calcular(infoLinea);
    ruta.addElement(punto);
    //Vemos si el vector ha sobrepasado el tamano maximo permitido.
    //Tenemos un contador "contadorMax" que indica que parte del vector
    //ya ha sido ordenado para no volver a sustraer elementos de esa
    //parte.
    if (ruta.size() > RUTA_MAX_SIZE + contadorMax) {
    //A partir de la posicion "contadorMax" reducimos el vector a la mitad.
    contadorMax = reduceRuta(contadorMax, 2);
    }
    infoLinea.lecturaFichero(inputStreamTxt);
    }
    //Si el vector completo supera el tamano maximo permitido, lo reducimos
    //en una pasada para que se aproxime a ese numero.
    if (ruta.size() > RUTA_MAX_SIZE) {
    reduceRuta(0, ruta.size() / RUTA_MAX_SIZE);
    }
    try {
    inputStreamTxt.close();
    } catch (IOException ex) {
    //controlador.muestraAlerta("Problema al cargar la ruta para dibujarla");
    ex.printStackTrace();
    }
    }




    private int reduceRuta(int contadorMax, int division) {
    // Algoritmo que reduce la cantidad de informacion contenida en un vector
    // de forma proporcional al parametro que se introduce
    // @param contadorMax Posicion a partir de la cual se empieza a reducir
    // el vector. Se presume que en pasadas anteriores se ha reducido la zona
    // predecesora. Si se quiere reducir el vector entero, contadorMax sera 0
    // @param division Factor de reduccion del vector
    // @return tamano del vector resultante tras la reduccion
    //TO-DO: IMPLEMENTAR UN ALGORITMO QUE BORRE ELEMENTOS EN LAS ZONAS DONDE
    //LAS COORDENADAS APENAS CAMBIAN (por ejemplo, semaforos) DE TAL FORMA
    //QUE APENAS SE PIERDA INFORMACION
    try {
    int j = 0;
    for (int i = contadorMax; i < ruta.size() + j; i++) {
    if (i % division != 0) {
    ruta.removeElementAt(i - j);
    j++;
    }
    }
    return ruta.size();
    } catch (Exception ex) {
    // controlador.muestraAlerta("Problema al reducir la ruta");
    return 0;
    }
    }

    public void setModoGmaps() {
    // Indica que el programa estÃ¡ funcionando en modo Google Maps
    modoGoogle = true;
    modoFichero = false;
    borrarPOI = false;
    contadorPOI = 0;
    }
    public void setModoFichero() {
    // Indica que el programa esta extrayendo datos de un fichero con una
    // ruta de coordenadas.
    modoFichero = true;
    modoGoogle = false;
    borrarPOI = false;
    contadorPOI = 0;
    }
    public void setModoGPS() {
    // Indica que el programa esta extrayendo datos de la seÃ±al de un
    // dispositivo GPS.

    modoFichero = false;
    borrarPOI = false;
    contadorPOI = 0;
    }
    public void Fichero(String nombre, String nombremapa) {
    borrarPOI = false;
    contadorPOI = 0;
    posicionMapa = new int[2];
    //"nombre" es la ruta del fichero de ruta, "nombremapa" es la ruta del fichero .map
    this.nombre = nombre;
    this.nombremapa = nombremapa;
    CalculosDatos.setInfoFichero(nombremapa);
    }

    public void Fichero(String nombremapa) {
    borrarPOI = false;
    contadorPOI = 0;
    posicionMapa = new int[2];
    //"nombremapa" es la ruta del fichero .map

    this.nombremapa = nombremapa;
    CalculosDatos.setInfoFichero(nombremapa);
    }

    private void inicializarTamanos(Graphics g) {

    // Metodo que define los tamanos del interfaz principal de Geomantes.
    // @param g Grafico donde se realizan las tareas del canvas
    //
    Font f = new Font("Arial", Font.BOLD, 10);
    FontMetrics fm = g.getFontMetrics();
    int lineHeight = fm.getHeight();
    //Altura de la barra de informacion superior: 3*lineHeight + 2*lineHeight
    //(3 lineas mas 4 espacios de 0.5 lineHeight).
    altInfo = 2 * lineHeight + 6;
    //altEspacio2 = (altInfo2 - 3*lineHeight)/4;
    altEspacio = (altInfo - 2 * lineHeight) / 3;
    //Altura de la barra de informacion inferior
    altInferior = (int) (1.5 * lineHeight);
    //Anchura de la pantalla

    //Tamano reservado para la velocidad
    int maxVel = fm.stringWidth("999"); //Tamano de la velocidad que consideramos maxima
    //f = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_MEDIUM);
    f = new Font("Arial", Font.PLAIN, 12);
    int tamtipoVel = fm.stringWidth("" + tipoVel);
    tamVel = maxVel + tamtipoVel + 4;
    //Tamano reservado para la brujula
    //f = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_BOLD, Font.SIZE_SMALL);
    f = new Font("Arial", Font.BOLD, 10);
    int tamCoord = fm.stringWidth("99.999999");
    //f = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_SMALL);
    f = new Font("Arial", Font.PLAIN, 10);
    int tamtipoCoord = fm.stringWidth("long");
    tamInfo = tamCoord + tamtipoCoord + 6;
    tamBordeInfo = tamInfo - tamCoord - tamtipoCoord;

    tamDist = fm.stringWidth("999km") + 5;
    if (ancho > tamVel + tamInfo + tamDist) {
    int sobrante = ancho - (tamVel + tamInfo + tamDist);
    tamVel = tamVel + sobrante / 3;
    tamInfo = tamInfo + sobrante / 3;
    tamBordeInfo = tamBordeInfo + sobrante / 3;
    tamDist = tamDist + sobrante / 3;
    }

    tamBruj = (int) (displayMapa.getWidth() * 0.16);
    tamBordeBruj = (int) (displayMapa.getWidth() * 0.045);
    centerX = ancho - tamBordeBruj - tamBruj / 2;
    centerY = alto - altInferior - tamBordeBruj - tamBruj / 2;

    Image b = Toolkit.getDefaultToolkit().
    getImage(getClass().getResource("/Archivos/brujula2.gif"));

    brujula = b.getScaledInstance(tamBruj, tamBruj, Image.SCALE_SMOOTH);
    // Inicializamos el angulo a uno mayor al maximo posible
    angle = -361;
    }
    private void paintDefault(Graphics g) {
    //Clear the background
    g.setColor(new Color(228, 228, 228));
    Font f = new Font("Arial", Font.PLAIN, 10);
    //Font.getFont(Font.FACE_SYSTEM, Font.STYLE_PLAIN, Font.SIZE_SMALL);
    g.setFont(f);
    g.fillRect(0, 0, ancho, alto);

    // Write title
    int titleX = ancho / 2;
    if (titulo != null) {
    g.drawImage(titulo, ancho / 4, (int) (alto * 0.4), titleX, (int) (alto * 0.4), null);
    } else {
    g.setColor(new Color(255, 255, 255));
    g.drawString("Geomantes", titleX, (int) (alto * 0.4));
    }
    }



    // MÃ©todo que se encarga de mostrar por pantalla los elementos propios
    // del modo NavegaciÃ³n guiada (flecha de orientaciÃ³n y distancia al
    // punto destino). TambiÃ©n se encarga de la reproducciÃ³n de las voces
    // de indicaciÃ³n.
    // @param g objeto de la clase Graphics

    public void paintModoGuiado(Graphics g) {
    Vector v = null;// = controlador.getVectorRutaGeoPoint();
    GeoPoint puntoActual = new GeoPoint(coordenadas.getLatitud(), coordenadas.getLongitud());
    Font fuente;
    if (numPuntosPasados == v.size()) {
    //Ruta completa
    //            g.drawImage(finDeRuta, getWidth() / 2, getHeight() - finDeRuta.getHeight() - 10, Graphics.HCENTER | Graphics.VCENTER);
    } else {

    if (puntoActual.isNearby((GeoPoint) v.elementAt(numPuntosPasados), 0.01)) {
    fuente = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_ITALIC, Font.SIZE_SMALL);
    g.setFont(fuente);
    g.drawString("Â¡Checkpoint!", 0, getHeight() - 60, 0);

    //         g.drawImage(rotuloCheck, getWidth() / 2, getHeight() - rotuloCheck.getHeight() - 10, Graphics.HCENTER | Graphics.VCENTER);

    numPuntosPasados++;
    }
    if (numPuntosPasados != v.size()) {
    double bearing = calcularBearing(coordenadas.getLatitud(), coordenadas.getLongitud(),
    ((GeoPoint) v.elementAt(numPuntosPasados)).getLatitude(),
    ((GeoPoint) v.elementAt(numPuntosPasados)).getLongitude());
    if ((numActualizaciones) == 0) {
    resta = angleGuiado - bearing;
    }
    flecha = calcularFlecha(resta);
    fuente = new Font("Arial", Font.BOLD, 12);
    g.setFont(fuente);


    double distanciaPunto = puntoActual.metersToPoint((GeoPoint) v.elementAt(numPuntosPasados));
    int distanciaPuntoRound = (int) ((distanciaPunto + 0.5));
    centerX = getWidth() - flecha.getWidth() - 5;
    centerY = getHeight() - getHeight() / 3 - 5;
    g.drawImage(flecha, centerX, centerY, 0);
    g.drawImage(rotuloVelocidad, centerX + flecha.getWidth() / 2 - 5, getHeight() - 45, Graphics.VCENTER | Graphics.HCENTER);
    g.drawString(String.valueOf(distanciaPuntoRound) + " m", centerX + flecha.getWidth() / 2, getHeight() - 40, Graphics.BASELINE | Graphics.HCENTER);

    if (numActualizaciones == 0) {
    numActualizaciones = 0;
    try {
    if (flecha == norte) {
    todorecto.start();
    } else if (flecha == sur || flecha == sureste || flecha == suroeste) {
    mediavuelta.start();
    } else if (flecha == este) {
    derecha.start();
    } else if (flecha == oeste) {
    izquierda.start();
    } else if (flecha == noroeste) {
    ligizquierda.start();
    } else if (flecha == noreste) {
    ligderecha.start();
    }
    } catch (Exception e) {
    }
    } else {
    numActualizaciones++;
    }

    }
    }
    }




    public double calcularBearing(double lat_ini, double lon_ini, double lat_fin, double lon_fin) {
    // MÃ©todo que calcula el Ã¡ngulo que forma el vector que une dos posiciones
    // con el norte
    // @param lat_ini latitud del punto origen
    // @param lon_ini longitud del punto origen
    // @param lat_fin latitud del punto destino
    // @param lon_fin longitud del punto destino
    // @return Ã¡ngulo del vector
    double latitudAntigua = toRad(lat_ini);
    double latitudActual = toRad(lat_fin);
    double dLon = toRad(lon_fin - lon_ini);

    double y = Math.sin(dLon) * Math.cos(latitudActual);
    double x = Math.cos(latitudAntigua) * Math.sin(latitudActual) -
    Math.sin(latitudAntigua) * Math.cos(latitudActual) * Math.cos(dLon);
    return toBrng(mMath.atan2(y, x));
    }

    public double toRad(double grados) {
    return grados * Math.PI / 180;
    }

    public double toBrng(double radianes) {
    return (toDeg(radianes) + 360) % 360;

    }

    public double toDeg(double radianes) {
    return radianes * 180 / Math.PI;
    }



    public Image calcularFlecha(double resta) {
    //
    // MÃ©todo que calcula la orientaciÃ³n de la flecha en el modo guiado
    // @param resta contiene la resta entre el Ã¡ngulo que forma con el norte
    // el vector de la direcciÃ³n del movimiento y el Ã¡ngulo que forma con el
    // norte el vector que une nuestra posiciÃ³n actual con el destino
    // @return imagen de la flecha

    Image flecha = norte;
    if (resta < 0) {
    resta = resta + 360;
    }
    if (resta >= 22.5 && resta < 67.5) {
    flecha = noroeste;
    } else if (resta >= 67.5 && resta < 112.5) {
    flecha = oeste;
    } else if (resta >= 112.5 && resta < 157.5) {
    flecha = suroeste;
    } else if (resta >= 157.5 && resta < 202.5) {
    flecha = sur;
    } else if (resta >= 202.5 && resta < 247.5) {
    flecha = sureste;
    } else if (resta >= 247.5 && resta < 292.5) {
    flecha = este;
    } else if (resta >= 292.5 && resta < 337.5) {
    flecha = noreste;
    } else if ((resta >= 337.5 && resta <= 360) || (resta >= 0 && resta < 22.5)) {
    flecha = norte;
    }
    return flecha;
    }

    private int[] rotate(double angle, int x, int y) {
    int rotated[] = new int[2];
    rotated[X] = (int) (Math.cos(angle) * x + Math.sin(angle) * y);
    rotated[Y] = (int) (-Math.sin(angle) * x + Math.cos(angle) * y);
    return rotated;
    }
    //
    // Rotate point (x,y) by degrees that angle parameter defines. The new
    // coordinate calculation is performed with a 2x2 rotate matrix.
    //
    // @param angle
    //            to be rotated
    // @param x
    //            coordinate
    // @param y
    //            coordinate
    // @return new coordinate pair in int array format [x,y]


    public void limpiaDisplay() {
    limpiaDisplay = true;
    }

    public void setModoGuiado(boolean b) {
    modoGuiado = b;
    }

    public void reset() {
    distancia = 0;
    numPuntosPasados = 0;
    numActualizaciones = 0;
    }

    private void drawArrow(Graphics g, double angle, int len, int spikeLen) {
    int a1[] = rotate(angle, 0, -(len - spikeLen));
    int b1[] = rotate(angle, -spikeLen, -(len - spikeLen));
    int c1[] = rotate(angle, 0, -len);
    int d1[] = rotate(angle, spikeLen, -(len - spikeLen));
    int e1[] = rotate(angle + (degree * 180.0), 0, -len);

    g.setColor(new Color(255, 0, 0));
    g.drawLine(centerX, centerY, centerX + a1[X], centerY + a1[Y]);
    //g.fillTriangle(centerX + b1[X], centerY + b1[Y], centerX + d1[X], centerY + d1[Y], centerX + c1[X], centerY + c1[Y]);
    g.setColor(new Color(255, 0, 0));
    g.drawLine(centerX, centerY, centerX + e1[X], centerY + e1[Y]);
    }
     */
    /*private void paintDescripcion(Graphics g, int alt, int anch, int x, int y, String d) {
    Font f = Font.getFont(Font.FACE_SYSTEM, Font.STYLE_ITALIC, Font.SIZE_SMALL);
    g.setFont(f);
    int textoAncho = f.stringWidth(d);
    int textoAlto = f.getHeight();

    Gradient.gradientBox(g, 0xfbd860, 0xfeefba, getWidth() / 2 - x, getHeight() / 2 - y - alt / 2 - textoAlto - 2, textoAncho + 5, textoAlto + 2, Gradient.VERTICAL);
    g.setColor(0xfeefba);
    g.fillTriangle(getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 4,
    getWidth() / 2 - x + anch / 2, getHeight() / 2 - y - alt / 2,
    getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 2);
    g.setColor(0x000000);

    g.drawLine(getWidth() / 2 - x, getHeight() / 2 - y - alt / 2 - textoAlto - 2,
    getWidth() / 2 - x, getHeight() / 2 - y - alt / 2);
    g.drawLine(getWidth() / 2 - x + textoAncho + 5, getHeight() / 2 - y - alt / 2 -
    textoAlto - 2, getWidth() / 2 - x + textoAncho + 5, getHeight() / 2 - y - alt / 2);
    g.drawLine(getWidth() / 2 - x, getHeight() / 2 - y - alt / 2 - textoAlto - 2,
    getWidth() / 2 - x + textoAncho + 5, getHeight() / 2 - y - alt / 2 - textoAlto - 2);
    g.drawLine(getWidth() / 2 - x, getHeight() / 2 - y - alt / 2, getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 2);
    g.drawLine(getWidth() / 2 - x + anch / 2, getHeight() / 2 - y - alt / 2,
    getWidth() / 2 - x + textoAncho + 5, getHeight() / 2 - y - alt / 2);
    g.drawLine(getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 4,
    getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 2);
    g.drawLine(getWidth() / 2 - x + anch / 4, getHeight() / 2 - y - alt / 4,
    getWidth() / 2 - x + anch / 2, getHeight() / 2 - y - alt / 2);
    g.drawRect(getWidth() / 2 - x, getHeight() / 2 - y - alt / 2 - textoAlto - 2,
    textoAncho + 5, textoAlto + 2);
    g.drawString(d, getWidth() / 2 - x + 1, getHeight() / 2 - y - alt / 2 - textoAlto - 1,
    Graphics.TOP | Graphics.LEFT);
    }*/
}




